Ham Radio 2000/Ham Radio 2000.iso/ham2000/packet/terminal/top_152/src152.exe/rar/TOPSCROL.PAS

Pascal/Delphi Source File | 1995-05-16 | 66KB | 1,994 lines

{┌─────────────────────────────────────────────────────────────────────────┐}
{│                                                                         │}
{│                              T. O. P.                                   │}
{│                                                                         │}
{│                        (T)he  (O)ther  (P)acket                         │}
{│                                                                         │}
{│ T O P S C R O L . P A S                                                 │}
{│                                                                         │}
{│                                                                         │}
{│ Routinen für den Backscroll des QSO-Fensters (Hauptbildschirm)          │}
{└─────────────────────────────────────────────────────────────────────────┘}


Procedure Notiz_Zeigen (* Kanal : Byte *);

Type      RetPtr    = array[0..maxNotLines] of Word;
          AttPtr    = array[0..maxNotLines] of Boolean;

Var       Groesse   : LongInt;
          Zeilen,
          abline,
          von,bis,
          i,i1,P,
          X,Y,XB,
          Result    : Integer;
          StartPage,
          StopPage,
          Z         : Word;
          b,Nx,
          AMark,
          AMerk     : Byte;
          MoStr     : String[80];
          Save_Name : String[60];
          Suchstr   : String[30];
          ablineStr : String[19];
          BlStr,
          Zstr      : String[2];
          KC        : Sondertaste;
          VC        : Char;
          NSave     : Text;
          RetFlag,
          gefunden,
          fertig,
          PFlag,
          VorEdit,
          MarkBlock,
          NowBlock,
          NowZlnMerk,
          CurObStat : Boolean;
          RET       : ^RetPtr;
          BlAttr    : ^AttPtr;

Label Nochmal,
      Nochmal1;

  Procedure GetRam;
  Var    i : Word;
  Begin
    if not MarkBlock then
    begin
      GetMem(BlAttr,Zeilen);
      FillChar(BlAttr^,Zeilen,0);
      for i := 1 to Zeilen do BlAttr^[i] := false;
      MarkBlock := true;
    end;
  End;

  Function Eig(Nr : Word) : Str2;
  Begin
    if (Kanal > 0) and (Page^[RET^[Nr]+1] = Attrib[19]) then Eig := EchoCh
                                                        else Eig := '';
  End;

  Procedure Array_updaten(Kanal : Byte);
  Var    NotPtr,
         CRPtr     : Pointer;
         max       : Word;
         ZL        : Integer;
  Begin
    with K[Kanal]^ do
    begin
      FillChar(Page^,maxNotCh,0);
      if use_EMS then EMS_Seite_einblenden(Kanal,Scr);

      if use_Vdisk then
      begin
        FiResult := ResetBin(ScrollFile,T);

        Seek(ScrollFile,Pos_im_Scr + NotPos);
        Blockread(ScrollFile,Page^[0],maxNotCh-1-NotPos,Z);

        Seek(ScrollFile,Pos_im_Scr);
        Blockread(ScrollFile,Page^[maxNotCh-1-NotPos],NotPos,Z);

        FiResult := CloseBin(ScrollFile);
      end else
      if use_XMS then
      begin
        XMS_to_Data(@Page^[0],XMS_Handle,Pos_im_Scr+NotPos,maxNotCh-1-NotPos);
        XMS_to_Data(@Page^[maxNotCh-1-NotPos],XMS_Handle,Pos_im_Scr,NotPos);
      end else
      begin
        move(NotCh[Kanal]^[NotPos],Page^[0],maxNotCh-1-NotPos);
        move(NotCh[Kanal]^[0],Page^[maxNotCh-1-NotPos],NotPos);
      end;
      Page^[maxNotCh-1] := 13;
      max := maxNotCh;
    end;

    NotPtr := @Page^[0];
    CRPtr := @RET^[1];

    asm  push ds
         mov  cx, max
         mov  bx, 0
         mov  dx, 0
         les  di, CRPtr
         lds  si, NotPtr
         jmp  @Weiter
    @CR:
         mov  [es:di], bx
         add  di, 2
         inc  dx
         jmp  @Again
@Weiter:
         mov  al, [ds:si]
         cmp  al, 13
         je   @CR
 @Again:
         inc  si
         inc  bx
         Loop @Weiter
         pop  ds
         mov  ZL, dx
    end;
    Zeilen := ZL;

    (*
    for ZL := 0 to K[Kanal]^.maxNotCh-1 do
    begin
      if Page^[ZL] = 13 then
      begin
        inc(Zeilen);
        RET^[Zeilen] := ZL;
      end;
    end;
    *)

    dec(Zeilen);
    if Zeilen <= 0 then Zeilen := 1;
  end;


  Function BringZeile(Kanal : Byte; Nr : Integer) : String;
  var      P    : Word;
           Hstr : String;
           Ze   : Byte;
  begin
    with K[Kanal]^ do
    begin
      Hstr := '';
      for P := (RET^[Nr]+2) to (RET^[Nr+1]-1) do
      begin
        Ze := Page^[P];
        if Ze in [1..31] then
        begin
          Ze := Ze + 64;
          Hstr := Hstr + '^';
        end;
        Hstr := Hstr + chr(Ze);
      end;
      BringZeile := Hstr;
    end;
  end;

  Procedure Zeig(Kanal,von,bis : Byte; PLine : Integer);
  var       i,i1,j,
            Attr   : Byte;
            Hstr   : String[80];
  Begin
    i1 := 0;
    if Zeilen > 1 then for i := von to bis do
    begin
      Attr := Page^[RET^[PLine+i1]+1];
      if Attr = 254 then Attr := 13;
      if (MarkBlock and BlAttr^[PLine+i1]) or ((i = Y) and not MarkBlock)
         then Attr := Attrib[4];
      FillChar(Hstr[1],80,32);
      Hstr[0] := Chr(80);
      j := Byte(RET^[PLine+i1+1] - RET^[PLine+i1] - 2);
      if j > 80 then j := 80;
      move(Page^[RET^[PLine+i1]+2],Hstr[1],j);
      WritePage(Kanal,1,i,Attr,0,Hstr);
      inc(i1);
    end;
  End;

  Procedure CursorUp(Kanal : Byte);
  Begin
    if abline + Y - von > 1 then
    begin
      dec(Y);
      if Y < von then
      begin
        Y := von;
        dec(abline);
        Scroll(Dn,1,von,bis);
      end;
      Zeig(Kanal,Y,Y+1,abline + Y - von);
    end;
  End;

  Procedure CursorDown(Ka : Byte);
  Var   Merk : Integer;
        Flag : Boolean;
  Begin
    Flag := false;
    if (K[Ka]^.NeueZeilen > 0) and not MarkBlock and
       not ((abline < (Zeilen - bis + von)) or (Y < bis)) then
    begin
      Merk := Zeilen;
      Array_updaten(Ka);
      abline := abline - (K[Ka]^.NeueZeilen - (Zeilen-Merk));
      K[Ka]^.ScrZlnMerk := Word(K[Ka]^.ScrZlnMerk + K[Ka]^.NeueZeilen);
      K[Ka]^.NeueZeilen := 0;

      if (abline < 1) and (Zeilen > bis - von) then
      begin
        abline := 1;
        Y := von;
        Zeig(Ka,von,bis,abline);
        Flag := true;
      end;
    end;

    If (abline + (Y-von) < Zeilen) and not Flag then
    begin
      inc(Y);
      if Y > bis then
      begin
        Y := bis;
        inc(abline);
        Scroll(Up,1,von,bis);
      end;
      Zeig(Ka,Y-1,Y,abline + (Y-1) - von);
    end;
  End;

  Procedure NewBild;
  Begin
    if abline > 0 then Zeig(Kanal,von,bis,abline)
                  else Zeig(Kanal,Y,bis,abline + Y-von);
  End;

  Procedure CancelBlock;
  Begin
    if MarkBlock then
    begin
      FreeMem(BlAttr,Zeilen);
      MarkBlock := false;
      StartPage := 0;
      StopPage := 0;
      Cursor_aus;
    end;
    NewBild;
  End;

Begin
  with K[Kanal]^ do
  begin
    Nx := (NrStat[2]-1) * 20 + 1;
    ScrZlnMerk := Word(ScrZlnMerk + NeueZeilen);
    NeueZeilen := 0;
    Neu_Bild;
    RetFlag := false;
    VorEdit := false;
    QsoScroll := true;
    CurObStat := false;
    MarkBlock := false;
    NowBlock := false;
    NowZlnMerk := false;
    StartPage := 0;
    StopPage := 0;
    XB := 1;
    if Braille80 then X := 80 else X := 1;
    Zeilen := 0;
    RET := Nil;
    Page := Nil;
    GetMem(RET,maxNotLines*2);
    FillChar(RET^,SizeOf(RET^),0);
    GetMem(Page,maxNotCh);

    Array_updaten(Kanal);

    if Kanal > 0 then
    begin
      von := QBeg;   bis := QEnd;
    end else
    begin
      von := UnStat + 1;   bis := maxZ;
    end;
    abline := Zeilen - (bis - von);
    Y := bis;
    Zeig(Kanal,Y,Y,abline + Y - von);
    WriteAttr(1,Y,80,Attrib[4],1);
    Fertig := false;
    SuchStr := '';

Nochmal:

    WriteRam(Nx+1,ObStat,Attrib[9],1,ConstStr(B1,19));
    Repeat
      i := ((Zeilen + 1) - abline) - (Y - von);
      i1 := abline + (Y-von);
      if MarkBlock then BlStr := S_ch
                   else BlStr := B1;
      if MarkBlock and BlAttr^[i1] then
      begin
        BlStr := '■' + BlStr;
        if not NowBlock and BlTon then Beep(G^.BLockAnfFreq,G^.BlockPiep1Time);
        NowBlock := true;
      end else
      begin
        BlStr := B1 + BlStr;
        if NowBlock and BlTon then Beep(G^.BLockEndFreq,G^.BlockPiep2Time);
        NowBlock := false;
      end;
      abLineStr := SFillStr(4,B1,int_str(i)) + '/' + int_str(Zeilen) + BlStr;
      WriteRam(Nx+1,ObStat,Attrib[9],1,EFillStr(9,B1,ablineStr));
      if HardCur and not VorEdit then
      begin
        if CurObStat then SetzeCursor(X,ObStat)
                     else SetzeCursor(X,Y);
      end else if MarkBlock then SetzeCursor(XB,Y);

      Repeat
        if TimerTick > PollTime then
        begin
          Uhr_aus;
          WriteRam(Nx+12,ObStat,Attrib[9],1,EFillStr(8,B1,LRK + int_str(NeueZeilen) + RRK));
          TNCs_Pollen;
          if notScroll then
          begin
            notScroll := false;
            if abline > 0 then Zeig(Kanal,von,bis,abline)
                          else Zeig(Kanal,Y,bis,abline + Y-von);
          end;
        end;
      Until _KeyPressed;
      _ReadKey(KC,VC);
      PollTime := TimerTick + KeyDelay;

      if VorEdit then
      begin
        if KC in [_Esc,_PgUp,_Alt0,_F11] then
        begin
          VorEdit := false;
          Zeig(Kanal,Y,Y,abline + Y-von);
        end else
        if KC in [_AltA.._AltY,_AltZ,_Home,_ShIns,_ShTab,_End,_Ins.._Ret,_Back,_Nix]
         then Key_Active(Kanal,KC,VC)
         else Alarm;
      end else
      case KC of
         _Up : CursorUp(Kanal);

         _Dn : CursorDown(Kanal);

       _Home : begin
                 if ScrZlnMerk >= Zeilen then ScrZlnMerk := Zeilen - 1;
                 if ScrZlnMerk > (bis - von) then Y := von
                                             else Y := bis - ScrZlnMerk;
                 i := abline;
                 abline := Zeilen - ScrZlnMerk + von - Y;
                 if abline > 0 then Zeig(Kanal,von,bis,abline) else
                 begin
                   abline := i;
                   Y := bis - ScrZlnMerk + 1;
                   if Y > bis then Y := bis;
                   Zeig(Kanal,Y,bis,abline + Y - von);
                 end;
               end;

       _End  : begin
                 ScrZlnMerk := Word(Zeilen - abline - Y + von);
                 NowZlnMerk := true;
               end;

       _PgUp : begin        { Page up     }
                 if abline > 0 then
                 begin
                   abline := abline - (bis-von);
                   if HardCur then Y := von + 1;
                   if abline <= 0 then
                   begin
                     abline := 1;
                     Y := von;
                   end;
                   Zeig(Kanal,von,bis,abline);
                 end else
                 begin
                   Y := bis - Zeilen + 1;
                   Zeig(Kanal,Y,bis,abline + Y-von);
                 end;
               end;

       _PgDn : begin        { Page down   }
                 PFlag := false;
                 if (NeueZeilen > 0) and not MarkBlock and
                    (abline + bis - von > Zeilen - bis + von) then
                 begin
                   i := Zeilen;
                   Array_updaten(Kanal);
                   abline := abline - (NeueZeilen - (Zeilen-i));
                   ScrZlnMerk := Word(ScrZlnMerk + NeueZeilen);
                   NeueZeilen := 0;

                   if (abline < 1) and (Zeilen > bis - von) then
                   begin
                     abline := 1;
                     Y := von;
                     Zeig(Kanal,von,bis,abline);
                     PFlag := true;
                   end;
                 end;

                 if not PFlag then if abline > 0 then
                 begin
                   abline := abline + (bis-von);
                   if HardCur then Y := von + 1;
                   if abline > (Zeilen - (bis - von)) then
                   begin
                     abLine := Zeilen - (bis - von);
                     Y := bis;
                   end;
                   Zeig(Kanal,von,bis,abline);
                 end else
                 begin
                   Y := bis;
                   Zeig(Kanal,Y-Zeilen+1,Y,1);
                 end;
               end;

   _CtrlPgUp : begin
                 if abline > 0 then
                 begin
                   abline := 1;
                   Y := von;
                   Zeig(Kanal,von,bis,abline);
                 end else
                 begin
                   Y := bis - Zeilen + 1;
                   Zeig(Kanal,Y,bis,abline + Y-von);
                 end;
               end;

   _CtrlPgDn : begin
                 if abline > 0 then
                 begin
                   abLine := Zeilen - (bis - von);
                   Y := bis;
                   Zeig(Kanal,von,bis,abline);
                 end else
                 begin
                   Y := bis;
                   Zeig(Kanal,Y-Zeilen+1,Y,1);
                 end;
               end;

   _CtrlHome : begin
                 if abline > 0 then
                 begin
                   Y := von;
                   Zeig(Kanal,von,bis,abline);
                 end else
                 begin
                   Y := bis - Zeilen + 1;
                   Zeig(Kanal,Y,bis,abline + Y-von);
                 end;
               end;

    _CtrlEnd : begin
                 if abline > 0 then
                 begin
                   Y := bis;
                   Zeig(Kanal,von,bis,abline);
                 end else
                 begin
                   Y := bis;
                   Zeig(Kanal,Y-Zeilen+1,Y,1);
                 end;
               end;

       _ShUp : if abline + (Y-von) > 1 then
               begin
                 GetRam;
                 if BlAttr^[abline + (Y-von)] then
                 begin
                   BlAttr^[abline + (Y-von)] := false;
                 end else
                 if BlAttr^[abline + (Y-von)-1] then
                 begin
                   BlAttr^[abline + (Y-von)-1] := false;
                 end else BlAttr^[abline + (Y-von)] := true;
                 CursorUp(Kanal);
               end;

       _ShDn : if abline + (Y-von) < Zeilen then
               begin
                 GetRam;
                 if BlAttr^[abline + (Y-von)] then
                 begin
                   BlAttr^[abline + (Y-von)] := false;
                 end else
                 if BlAttr^[abline + (Y-von)+1] then
                 begin
                   BlAttr^[abline + (Y-von)+1] := false;
                 end else BlAttr^[abline + (Y-von)] := true;
                 CursorDown(Kanal);
               end;

    _ShRight : begin
                 GetRam;
                 BlAttr^[abline + (Y-von)] := not BlAttr^[abline + (Y-von)];
                 Zeig(Kanal,Y,Y,abline + Y-von);
               end;

       _Alt1 : StartPage := abline + (Y-von);

       _Alt2 : if StartPage > 0 then
               begin
                 GetRam;
                 StopPage := abline + (Y-von);
                 if StartPage > StopPage then
                 begin
                   i := StopPage;
                   StopPage := StartPage;
                   StartPage := i;
                 end;
                 for i := StartPage to StopPage do BlAttr^[i] := true;
                 StartPage := 0;
                 NewBild;
               end else Alarm;

     _AltF, _AltN :
               If ((Zeilen + 1) - abline) - (Y - von) > 1 then
               begin
                 if (KC = _AltN) and (Suchstr > '') then goto Nochmal1;
                 WriteRam(1,Y,Attrib[4],1,EFillStr(80,B1,InfoZeile(7)));
                 GetString(Suchstr,Attrib[4],30,45,Y,KC,0,Ins);
                 if KC <> _Esc then
                 begin
       Nochmal1:
                   i := abline + (Y-von) +1;
                   gefunden := false;
                   Repeat
                     gefunden := pos(Suchstr,UpCaseStr(BringZeile(Kanal,i))) > 0;
                     inc(i);
                   Until gefunden or (i > Zeilen);
                   if gefunden then
                   begin
                     if (i > Zeilen - (bis - von)) and ((Zeilen-i) < (bis-Y)) then
                     begin
                       abline := Zeilen - (bis - von);
                       Y := ((i - abline) + von) - 1;
                     end else  abline := (i - Y) + (von - 1);
                     if abline > 0 then Zeig(Kanal,von,bis,abline)
                                   else Zeig(Kanal,Y,bis,abline + Y-von);
                     if Klingel then Beep(1500,30);
                   end else
                   begin
                     Teil_Bild_Loesch(Y,Y,Attrib[4]);
                     WriteRam(10,Y,Attrib[4],1,InfoZeile(9));
                     Alarm;
                     Verzoegern(ZWEI);
                   end;
                 end;
                 if abline > 0 then Zeig(Kanal,von,bis,abline)
                               else Zeig(Kanal,bis-Zeilen+1,bis,1);
                 VC := #255;
                 goto Nochmal;
               end else Alarm;

       _Ret,
       _AltZ : if Zeilen > 1 then
               begin
                 if KC = _AltZ then Zstr := '> ' else Zstr := '';
                 if Vor_im_EMS then EMS_Seite_einblenden(Kanal,Vor);
                 if RetFlag then Chr_Vor_Show(Kanal,_Alt7,#255);
                 VorWrite[Kanal]^[stV] := Zstr + BringZeile(Kanal,abline + (Y-von));
                 Chr_Vor_Show(Kanal,_End,#255);
                 RetFlag := true;
                 CursorDown(Kanal);
                 goto Nochmal;
               end else Alarm;

       _AltG : begin
                 SysopParm := true;
                 PassRetry := 1;
                 PassRight := 1;
                 SysopArt := LRK + CutStr(User_Name) + RRK;
                 MoStr := BringZeile(Kanal,abline + (Y-von));
                 if pos(RSK,MoStr) = 0 then MoStr := RSK + MoStr;
                 Password_Auswert(Kanal,MoStr + M1);
               end;

       _AltH : TOP_Help(G^.OHelp[19]);

       _AltM : if Kanal = 0 then
               begin
                 MoStr := BringZeile(Kanal,abline + (Y-von));

                 i := pos(LRK,MoStr);
                 i1 := pos(LRK + B1,MoStr);
                 if (i = 1) and (i1 = 4) then delete(MoStr,1,5);

                 i := pos(fm,MoStr);
                 i1 := pos(zu,MoStr);
                 if (i > 0) and (i1 > i) then
                 begin
                   delete(MoStr,i1,3);
                   delete(MoStr,1,i+2);
                 end;

                 i := pos(DP,MoStr);
                 if i = 2 then delete(MoStr,1,2);

                 i := pos(RSK,MoStr);
                 if i <= 10 then MoStr[i] := B1;
                 FreeMonitorKanal(b,ParmStr(1,B1,MoStr) + B1 + ParmStr(2,B1,MoStr));
                 if b > 0 then
                 begin
                   Calls_Monitoren(b,ParmStr(1,B1,MoStr) + B1 + ParmStr(2,B1,MoStr));
                   if abline > 0 then Zeig(Kanal,von,bis,abline)
                                 else Zeig(Kanal,bis-Zeilen+1,bis,1);
                 end else Alarm;
               end else Alarm;

       _AltP : begin
                 if LPT_vorhanden and Lpt_All_Ok(PrtPort) then
                 begin
                   YScrolPos := Y;
                   if MarkBlock then
                   begin
                     for i := 1 to Zeilen do if BlAttr^[i] and not PrtFailure then
                      Write_Drucker(Kanal,Eig(i) + BringZeile(Kanal,i) + M1);
                     CancelBlock;
                   end else for i := abline + (Y-von) to Zeilen do
                    if not PrtFailure
                     then Write_Drucker(Kanal,Eig(i) + BringZeile(Kanal,i) + M1);
                 end else
                 begin
                   WriteRam(1,Y,Attrib[4],1,EFillStr(80,B1,InfoZeile(290)));
                   Alarm;
                   Verzoegern(ZWEI);
                 end;
                 Zeig(Kanal,Y,Y,abline + Y-von);
                 VC := #255;
                 goto Nochmal;
               end;

       _AltS : Begin   { Saven }
                 WriteRam(1,Y,Attrib[4],1,EFillStr(80,B1,B1+InfoZeile(142)+B1));
                 Save_Name := G^.SavePfad + 'SCR.'+ SFillStr(3,'0',int_str(Kanal));
                 GetString(Save_Name,Attrib[4],60,9,Y,KC,1,Ins);
                 if KC <> _Esc then
                 begin
                   Assign(NSave,Save_Name);
                   Result := AppendTxt(NSave);
                   if Result <> 0 then Result := RewriteTxt(NSave);
                   if Result = 0 then
                   begin
                     if MarkBlock then
                     begin
                       for i := 1 to Zeilen do
                        if BlAttr^[i] then Writeln(NSave,Eig(i),BringZeile(Kanal,i));
                       CancelBlock;
                     end else for i := abline + (Y-von) to Zeilen do
                                       Writeln(NSave,Eig(i),BringZeile(Kanal,i));
                     FiResult := CloseTxt(NSave);
                   end else
                   begin
                     WriteRam(1,Y,Attrib[4],1,EFillStr(80,B1,B1 +
                                  InfoZeile(75) + DP + B2 + Save_Name));
                     Alarm;
                     Verzoegern(ZWEI);
                   end;
                 end;
                 VC := #255;
                 Zeig(Kanal,Y,Y,abline + Y-von);
               end;

      _ShTab : begin
                 CurObStat := not CurObStat;
                 if CurObStat then X := ((NrStat[2]-1)*20)+1 else X := 80;
               end;

     _Tab    : CancelBlock;

     _Ins    : begin
                 VorEdit := true;
                 WriteRam(1,Y,Attrib[4],1,ConstStr(#24,80));
                 Chr_Vor_Show(Kanal,_Nix,#255);
               end;

   _F1.._F10,
   _F12      : begin
                 ch_aus := true;
                 SK_out := KC;
                 VC_out := VC;
                 Fertig := true;
               end;

        _Del, _Esc
             : Fertig := true;

     _Andere : Alarm;
        else Alarm;
      end;      (* case *)
    Until Fertig;
    if MarkBlock then FreeMem(BlAttr,Zeilen);
    if ZlnMerk and not NowZlnMerk then ScrZlnMerk := Word(Zeilen - abline - Y + von);
    FreeMem(Page,maxNotCh);
    FreeMem(RET,maxNotLines*2);
    QsoScroll := false;
    Cursor_aus;
    if HardCur then JumpRxScr := true;
    Neu_Bild;
  end;
End;


Procedure FileScroll (* Kanal : Byte *);
var     KC        : Sondertaste;
        VC,
        Hch       : Char;
        Lines     : ^MbxTypPtr;
        A,X,Y,
        maxY,
        minY,
        Nx,
        Attr,
        XMerk,
        Spalte,
        AnzSp,
        Yofs      : Byte;
        maxL,
        Result    : Word;
        i,i1,
        Lpos,
        Fpos,
        MFpos,
        FSize,
        Zmax,
        MmaxL     : LongInt;
        HLstr     : MbxZeile;
        Bstr,
        Hstr      : String[80];
        Save_Name : String[60];
        SuchStr   : String[30];
        Ende,
        Found,
        update,
        RetFlag,
        New_Lines,
        CurObStat,
        UpScroll,
        Fail,
        VorEdit,
        First     : Boolean;
        BoxSave   : Text;


  Function  MakeStr(Zeile : MbxZeile; Art : Byte; var Col : Byte) : StrBox;
  var   Hstr : String[BoxRec];
  Begin
    move(Zeile,Hstr[1],BoxRec);
    Hstr[0] := Chr(BoxRec);
    Col := Ord(Hstr[81]);
    case Art of
      0 : Hstr[0] := Chr(80);
      1 : delete(Hstr,1,83);
      2 : Hstr := copy(Hstr,82,2);
    end;
    MakeStr := Hstr;
  End;

  Procedure DoPage(von,bis : Byte);
  var  i,i1 : LongInt;
       Hstr : String[80];
  begin
    i1 := Lpos - Y + von;
    for i := von to bis do
    begin
      Hstr := MakeStr(Lines^[i1],0,Attr);
      WriteRam(1,i+Yofs,Attr,1,Hstr);
      inc(i1);
    end;
  end;

  Procedure Updaten(Kanal : Byte);
  var  l : LongInt;
  Begin
    with K[Kanal]^ do
    begin
      Seek(DBox,MFpos);
      for l := 1 to MmaxL do BlockWrite(DBox,Lines^[l],1,Result);
      update := false;
    end;
  End;

  Procedure HoleLines(Kanal : Byte; Stelle : LongInt);
  var   l      : LongInt;
        Result : Word;
  Begin
    with K[Kanal]^ do
    begin
      if update then Updaten(Kanal);
      FillChar(Lines^,SizeOf(Lines^),0);
      l := 1;
      Seek(DBox,Stelle);
      While not Eof(DBox) and (l <= maxL) do
      begin
        BlockRead(DBox,Lines^[l],1,Result);
        inc(l);
      end;
      MFpos := Stelle;
      MmaxL := maxL;
    end;
  End;

  Procedure CursorDown(Kanal : Byte);
  Begin
    with K[Kanal]^ do
    begin
      if (Fpos + Lpos) < FSize then
      begin
        DoPage(Y,Y);
        if Lpos < maxL then inc(Lpos) else
        begin
          Fpos := Fpos + maxL - Zmax + 1;
          Lpos := Zmax;
          if Fpos + maxL > FSize then
          begin
            Lpos := maxL + Fpos + Zmax - FSize;
            Fpos := FSize - maxL;
          end;
          HoleLines(Kanal,Fpos);
        end;
        if Y < Zmax then inc(Y) else
        begin
          Scroll(Up,1,minY,maxY);
          DoPage(Y,Y);
        end;
      end else Alarm;
    end;
  End;

  Procedure CursorUp(Kanal : Byte);
  Begin
    with K[Kanal]^ do
    begin
      if (Fpos + Lpos > 1) then
      begin
        DoPage(Y,Y);
        if Lpos > 1 then dec(Lpos) else
        begin
          Fpos := Fpos - maxL + Zmax - 1;
          Lpos := maxL - Zmax + 1;
          if Fpos < 0 then
          begin
            Lpos := Fpos + 1 - Zmax + maxL;
            Fpos := 0;
          end;
          HoleLines(Kanal,Fpos);
        end;
        if Y > 1 then dec(Y) else
        begin
          Scroll(Dn,1,minY,maxY);
          DoPage(Y,Y);
        end;
      end else Alarm;
    end;
  End;

  Procedure MakeRead(Kanal,Art : Byte; var FFlag : Boolean);
  var   VwStr  : String[80];
        Nstr   : String[12];
        RubStr : String[12];
        Astr   : String[2];
        Typ,
        A,b    : Byte;

    Procedure MakeTransfer;
    Begin
      VwStr := TrStr + B1 + RubStr + B1 + Nstr + B1;
      if Typ in [1,14] then VwStr := VwStr + RSK + B1;
      WriteRam(1,Y+Yofs,Attrib[4],1,ConstStr(B1,80));
      GetString(VwStr,Attrib[4],60,2,Y+Yofs,KC,3,Ins);
      if KC <> _Esc then
      begin
        Lines^[Lpos][b] := RepCh;
        A := Attrib[19];
      end else FFlag := true;
    End;

  Begin
    with K[Kanal]^ do
    begin
      VwStr := '';
      FFlag := false;
      b := 80;
      Hstr := MakeStr(Lines^[Lpos],0,Attr);
      Astr := MakeStr(Lines^[Lpos],2,Attr);
      Typ := Ord(Astr[2]);

      case Typ of
        1: begin (* DBOX *)
             case Astr[1] of
              'C': begin  (* CHECK-Eintrag *)
                     RubStr := MakeStr(Lines^[Lpos],1,Attr);
                     KillEndBlanks(Rubstr);
                     Nstr := ParmStr(4,B1,Hstr);
                     if length(Nstr) > 8 then
                     begin
                       Nstr := copy(Nstr,9,4);
                       While copy(Nstr,1,1) = Pkt do delete(Nstr,1,1);
                     end else Nstr := ParmStr(1,B1,Hstr);

                     case Art of
                       0: begin  (* R ABC X *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin (* E ABC X *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       2: begin (* SETL ABC X #Y *)
                            A := Attrib[20];
                            VwStr := SetStr + B1 + RubStr + B1 + Nstr +
                                     B1 + LZ + int_str(G^.SETL[SETNr]);
                            Lines^[Lpos][b] := SetCh;
                          end;
                       7: begin  (* REP ABC X *)
                            A := Attrib[19];
                            VwStr := RepStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := RepCh;
                          end;
                      11: begin  (* TR ABC X > ... *)
                            MakeTransfer;
                          end;
                       else FFlag := true;
                     end;
                   end;
              'L': begin  (* LIST-Eintrag *)
                     RubStr := MakeStr(Lines^[Lpos],1,Attr);
                     KillEndBlanks(RubStr);
                     Nstr := ParmStr(1,B1,Hstr);
                     case Art of
                       0: begin  (* R ABC X *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin  (* E ABC X *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       2: begin  (* SETL ABC X #Y *)
                            A := Attrib[20];
                            VwStr := SetStr + B1 + RubStr + B1 + Nstr +
                                     B1 + LZ + int_str(G^.SETL[SETNr]);
                            Lines^[Lpos][b] := SetCh;
                          end;
                       7: begin  (* REP ABC X *)
                            A := Attrib[19];
                            VwStr := RepStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := RepCh;
                          end;
                      11: begin  (* TR ABC X > ... *)
                            MakeTransfer;
                          end;
                       else FFlag := true;
                     end;
                   end;
              'R': begin  (* EL-Einträge, Dateien *)
                     case Art of
                       4 : VwStr := BinStr;  (* EL B *)
                       5 : VwStr := BsStr;   (* EL BS *)
                       6 : VwStr := PlusStr; (* EL 7 *)
                      else VwStr := Readstr; (* EL R *)
                     end;
                     A := Attrib[19];
                     VwStr := RunStr + B1 + ElStr + B1 + VwStr + B1 + ParmStr(1,B1,Hstr);
                     Lines^[Lpos][b] := ReadCh;
                   end;
              'V': begin  (* EL-Einträge, Verzeichnisse *)
                     A := Attrib[19];
                     VwStr := RunStr + B1 + ElStr + B1 + DirStr + B1 + CutStr(Hstr); (* EL D *)
                     Lines^[Lpos][b] := ReadCh;
                   end;
              else FFlag := true;
             end;
           end;

        2: begin (* BBOX *)
             case Astr[1] of
              'C': begin  (* CHECK-Eintrag *)
                     RubStr := MakeStr(Lines^[Lpos],1,Attr);
                     KillEndBlanks(Rubstr);
                     Nstr := ParmStr(4,B1,Hstr);
                     if length(Nstr) > 8 then
                     begin
                       Nstr := copy(Nstr,9,4);
                       While copy(Nstr,1,1) = Pkt do delete(Nstr,1,1);
                     end else Nstr := ParmStr(1,B1,Hstr);

                     case Art of
                       0: begin  (* R ABC X *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin (* E ABC X *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       2: begin (* SETL ABC X #Y *)
                            A := Attrib[20];
                            VwStr := SetStr + B1 + RubStr + B1 + Nstr +
                                     B1 + LZ + int_str(G^.SETL[SETNr]);
                            Lines^[Lpos][b] := SetCh;
                          end;
                       7: begin  (* REP ABC X *)
                            A := Attrib[19];
                            VwStr := RepStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := RepCh;
                          end;
                       9: begin  (* K ABC X *)
                            A := Attrib[19];
                            VwStr := KbStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := KbCh;
                          end;
                      11: begin  (* TR ABC X ... *)
                            MakeTransfer;
                          end;
                       else FFlag := true;
                     end;
                   end;
              'L': begin  (* LIST-Eintrag *)
                     RubStr := MakeStr(Lines^[Lpos],1,Attr);
                     KillEndBlanks(RubStr);
                     Nstr := ParmStr(1,B1,Hstr);
                     case Art of
                       0: begin  (* R ABC X *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin  (* E ABC X *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       2: begin  (* SETL ABC X #Y *)
                            A := Attrib[20];
                            VwStr := SetStr + B1 + RubStr + B1 + Nstr +
                                     B1 + LZ + int_str(G^.SETL[SETNr]);
                            Lines^[Lpos][b] := SetCh;
                          end;
                       7: begin  (* REP ABC X *)
                            A := Attrib[19];
                            VwStr := RepStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := RepCh;
                          end;
                       9: begin  (* K ABC X *)
                            A := Attrib[19];
                            VwStr := KbStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := KbCh;
                          end;
                      11: begin  (* TR ABC X ... *)
                            MakeTransfer;
                          end;
                       else FFlag := true;
                     end;
                   end;
              'R': begin  (* EL-Einträge, Dateien *)
                     case Art of
                       4 : VwStr := BinStr;  (* EL B *)
                       5 : VwStr := BsStr;   (* EL BS *)
                       6 : VwStr := PlusStr; (* EL 7 *)
                      else VwStr := Readstr; (* EL R *)
                     end;
                     A := Attrib[19];
                     VwStr := ElStr + B1 + VwStr + B1 + ParmStr(1,B1,Hstr);
                     Lines^[Lpos][b] := ReadCh;
                   end;
              'V': begin  (* EL-Einträge, Verzeichnisse *)
                     A := Attrib[19];
                     VwStr := ElStr + B1 + DirStr + B1 + CutStr(Hstr); (* EL D *)
                     Lines^[Lpos][b] := ReadCh;
                   end;
              else FFlag := true;
             end;
           end;

        3: begin (* FBOX *)
             case Astr[1] of
              'L': begin  (* LIST-Eintrag *)
                     KillStartBlanks(Hstr);
                     Nstr := ParmStr(1,B1,Hstr);
                     case Art of
                       0: begin  (* R XXX *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin (* K XXX *)
                            A := Attrib[20];
                            VwStr := KillStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       else FFlag := true;
                     end;
                   end;
              else FFlag := true;
             end;
           end;

        4: begin (* WBOX *)
             case Astr[1] of
              'C': begin  (* CHECK-Eintrag *)
                     KillStartBlanks(Hstr);
                     Nstr := CutStr(Hstr);
                     case Art of
                       0: begin  (* R XXX *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin (* E XXX *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       else FFlag := true;
                     end;
                   end;
              else FFlag := true;
             end;
           end;

        5: begin (* EBOX *)
             case Astr[1] of
              'L': begin  (* LIST-Eintrag *)
                     KillStartBlanks(Hstr);
                     Nstr := CutStr(Hstr);
                     case Art of
                       0: begin (* R XXX *)  (* RB XXX *)
                            A := Attrib[19];
                            if UpCaseStr(ParmStr(8,B1,Hstr)) = 'D'
                             then VwStr := RBinStr + B1 + Nstr
                             else VwStr := ReadStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin   (* K XXX *)
                            A := Attrib[20];
                            VwStr := KillStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       8: begin   (* U XXX *)
                            A := Attrib[19];
                            VwStr := UnprStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                      10: begin   (* CRC XXX *)
                            A := Attrib[19];
                            VwStr := CrcStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       else FFlag := true;
                     end;
                   end;
              else FFlag := true;
             end;
           end;

       14: begin (* TBOX *)
             case Astr[1] of
              'C': begin  (* CHECK-Eintrag *)
                     RubStr := MakeStr(Lines^[Lpos],1,Attr);
                     KillEndBlanks(Rubstr);
                     Nstr := ParmStr(4,B1,Hstr);
                     if length(Nstr) > 8 then
                     begin
                       Nstr := copy(Nstr,9,4);
                       While copy(Nstr,1,1) = Pkt do delete(Nstr,1,1);
                     end else Nstr := ParmStr(1,B1,Hstr);

                     case Art of
                       0: begin  (* R ABC X *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin (* E ABC X *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       2: begin (* SETL ABC X #Y *)
                            A := Attrib[20];
                            VwStr := SetStr + B1 + RubStr + B1 + Nstr +
                                     B1 + LZ + int_str(G^.SETL[SETNr]);
                            Lines^[Lpos][b] := SetCh;
                          end;
                       7: begin  (* REP ABC X *)
                            A := Attrib[19];
                            VwStr := RepStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := RepCh;
                          end;
                      11: begin  (* TR ABC X > ... *)
                            MakeTransfer;
                          end;
                       else FFlag := true;
                     end;
                   end;
              'L': begin  (* LIST-Eintrag *)
                     RubStr := MakeStr(Lines^[Lpos],1,Attr);
                     KillEndBlanks(RubStr);
                     Nstr := ParmStr(1,B1,Hstr);
                     case Art of
                       0: begin  (* R ABC X *)
                            A := Attrib[19];
                            VwStr := ReadStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := ReadCh;
                          end;
                       1: begin  (* E ABC X *)
                            A := Attrib[20];
                            VwStr := EraseStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := EraseCh;
                          end;
                       2: begin (* SETL ABC X #Y *)
                            A := Attrib[20];
                            VwStr := SetStr + B1 + RubStr + B1 + Nstr +
                                     B1 + LZ + int_str(G^.SETL[SETNr]);
                            Lines^[Lpos][b] := SetCh;
                          end;
                       7: begin  (* REP ABC X *)
                            A := Attrib[19];
                            VwStr := RepStr + B1 + RubStr + B1 + Nstr;
                            Lines^[Lpos][b] := RepCh;
                          end;
                      11: begin  (* TR ABC X > ... *)
                            MakeTransfer;
                          end;
                       else FFlag := true;
                     end;
                   end;
              else FFlag := true;
             end;
           end;
        else FFlag := true;
      end;

      if not FFlag then
      begin
        if not RetFlag then Chr_Vor_Show(Kanal,_Alt8,#255)
                       else Chr_Vor_Show(Kanal,_Andere,^J);
        VorWrite[Kanal]^[stV] := VwStr;
        update := true;
        Lines^[Lpos][81] := Chr(A);
        Chr_Vor_Show(Kanal,_End,#255);
        RetFlag := true;
        DoPage(1,Zmax);
      end;
    end;
  End;

  Function NoHeader(Zeile : MbxZeile) : Boolean;
  var  Attr : Byte;
  Begin
    NoHeader := pos('∙ ',MakeStr(Zeile,0,Attr)) <> 1;
  End;


Begin
  with K[Kanal]^ do
  begin
    Neu_Bild;
    if not ChkLstOpen then OpenDBox(Kanal);
    BoxScroll := true;
    if Vor_im_EMS then EMS_Seite_einblenden(Kanal,Vor);
    if Braille80 then X := 80 else X := 1;
    Y := 1;
    Ende := false;
    VorEdit := false;
    Nx := (NrStat[2]-1) * 20 + 1;
    Fpos := 0;
    Lpos := 1;
    SuchStr := '';
    CurObStat := false;
    First := true;
    New_Lines := false;
    update := false;
    RetFlag := false;
    UpScroll := false;
    Yofs := QBeg - 1;
    minY := QBeg;
    maxY := QEnd;
    Zmax := QEnd - QBeg + 1;
    Teil_Bild_Loesch(minY,maxY,Attrib[18]);
    KC := _CtrlPgDn;
    VC := #255;

    Repeat
      if not First then
      begin
        Repeat
          if TimerTick > PollTime then
          begin
            New_Lines := false;
            Uhr_aus;
            TNCs_Pollen;
            if (FSize <= (QEnd - QBeg + 5)) and (NewChkLst > 0) then New_Lines := true;
          end;
        Until New_Lines or _KeyPressed;
        if not New_Lines then _ReadKey(KC,VC);
      end;
      PollTime := TimerTick + KeyDelay;

      Fail := false;

      if FSize <= maxMbxLines then maxL := FSize
                              else maxL := maxMbxLines;
      if FSize <= Zmax then Zmax := FSize
                       else Zmax := QEnd - Yofs;
      if maxL <= Zmax then Zmax := maxL;
      maxY := Zmax + Yofs;

      if First then
      begin
        GetMem(Lines,SizeOf(Lines^));
        FillChar(Lines^,SizeOf(Lines^),0);
        if FSize = 0 then
        begin
          First := false;
          HoleLines(Kanal,0);
          DoPage(1,Zmax);
        end;
      end;

      if New_Lines then
      begin
        New_Lines := false;
        KC := _Tab;
      end;

      if NewChkLst > 0 then
      begin
        HoleLines(Kanal,Fpos);
        NewChkLst := 0;
      end;

      if VorEdit then
      begin
        if KC in [_Esc,_PgUp,_Alt0,_F11] then
        begin
          VorEdit := false;
          DoPage(Y,Y);
        end else
        if KC in [_AltA.._AltY,_AltZ,_Home,_ShIns, _ShTab,_End,_Ins.._Ret,_Back,_Nix]
         then Key_Active(Kanal,KC,VC)
         else Alarm;
      end else
      case KC of
      _Andere : begin
                  if UpCase(VC) in [' ','K','L','R','D','B','S','T','7','C','U'] then
                  begin
                    if NoHeader(Lines^[Lpos]) then
                    case UpCase(VC) of
                      ' ' : MakeRead(Kanal,0,Fail);  (* R... 123 *)

                      'T' : MakeRead(Kanal,11,Fail); (* TR IBM 123 *)

                      'K' : MakeRead(Kanal,9,Fail);  (* K IBM 123 *)
                      'L' : MakeRead(Kanal,2,Fail);  (* SETL IBM 123 *)
                      'R' : MakeRead(Kanal,7,Fail);  (* REP IBM 123 *)

                      'D' : MakeRead(Kanal,3,Fail);  (* EL D *)
                      'B' : MakeRead(Kanal,4,Fail);  (* EL B *)
                      'S' : MakeRead(Kanal,5,Fail);  (* EL BS *)
                      '7' : MakeRead(Kanal,6,Fail);  (* EL 7 *)

                      'C' : MakeRead(Kanal,10,Fail); (* CRC 12345 *)
                      'U' : MakeRead(Kanal,8,Fail);  (* U 12345 *)
                    end else Fail := true;

                    if not Fail then
                    begin
                      if UpScroll then CursorUp(Kanal)
                                  else CursorDown(Kanal);
                    end else
                    begin
                      Alarm;
                      DoPage(Y,Y);
                    end;
                  end else if (VC = ^Y) then
                  begin
                    FillChar(Lines^[Lpos],79,B1);
                    update := true;
                    DoPage(Y,Y);
                  end else Alarm;
                end;

        _Back : begin
                  UpScroll := not UpScroll;
                  if UpScroll
                  then WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,ConstStr(B1,20) + InfoZeile(87)))
                  else WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,ConstStr(B1,20) + InfoZeile(88)));
                  Verzoegern(700);
                  DoPage(Y,Y);
                end;

        _Del,
        _Esc  : Ende := true;

        _Tab  : begin
                  HoleLines(Kanal,Fpos);
                  DoPage(1,Zmax);
                end;

        _Ret  : begin
                  if not RetFlag then
                  begin
                    if NoHeader(Lines^[Lpos]) then
                    begin
                      MakeRead(Kanal,0,Fail);
                      if Fail then Alarm;
                    end else Alarm;
                  end;
                  if RetFlag then
                  begin
                    Chr_Vor_Show(Kanal,_Ret,#13);
                    RetFlag := false;
                  end;
                end;

        _F11,
        _Alt1..
        _Alt5 : begin
                  if KC = _F11 then
                  begin
                    KC := _Alt4;
                    VC := #123;
                  end;
                  if update then Updaten(Kanal);
                  Hstr := MakeStr(Lines^[Lpos],2,Attr);
                  Hch := Hstr[1];
                  if Hch in ['L','C'] then
                  begin
                    WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,ConstStr(B1,20) + InfoZeile(39)));
                    Hstr := MakeStr(Lines^[Lpos],0,Attr);

                    A := ord(VC) - 119;

                    Bstr := ParmStr(A,B1,Hstr);
                    if A = 1 then Spalte := 1
                             else Spalte := ParmPos;
                    Bstr := ParmStr(A+1,B1,Hstr);
                    AnzSp := Byte(ParmPos - Spalte);

                    FreeMem(Lines,SizeOf(Lines^));
                    CheckSort(Kanal,Spalte,AnzSp,Fpos + Lpos - 1,Hch);
                    GetMem(Lines,SizeOf(Lines^));
                    HoleLines(Kanal,Fpos);
                    DoPage(1,Zmax);
                  end else Alarm;
                end;

         _Ins : begin
                  VorEdit := true;
                  WriteRam(1,Y+Yofs,Attrib[4],1,ConstStr(#24,80));
                  Chr_Vor_Show(Kanal,_Nix,#255);
                end;

        _AltC : begin
                  Hstr := MakeStr(Lines^[Lpos],0,Attr);
                  KillEndBlanks(Hstr);
                  VorWrite[Kanal]^[stV] := Hstr;
                  Chr_Vor_Show(Kanal,_End,#255);
                  Chr_Vor_Show(Kanal,_Alt7,#255);
                  if UpScroll then CursorUp(Kanal)
                              else CursorDown(Kanal);
                end;

        _AltE : if NoHeader(Lines^[Lpos]) then
                begin
                  MakeRead(Kanal,1,Fail);
                  if not Fail then
                  begin
                    if UpScroll then CursorUp(Kanal)
                                else CursorDown(Kanal);
                  end else Alarm;
                end else Alarm;

        _AltH : TOP_Help(G^.OHelp[29]);

        _AltF,
        _AltN : begin
                  if (KC = _AltF) or ((KC = _AltN) and (SuchStr = '')) then
                  begin
                    WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,InfoZeile(7)));
                    GetString(Suchstr,Attrib[4],30,45,Y+Yofs,KC,0,Ins);
                  end;
                  if (KC <> _Esc) and (SuchStr > '') then
                  begin
                    Found := false;
                    Seek(DBox,Fpos + Lpos);
                    While not Found and not Eof(DBox) do
                    begin
                      BlockRead(DBox,HLstr,1,Result);
                      Hstr := UpCaseStr(MakeStr(HLstr,0,Attr));
                      Found := pos(SuchStr,Hstr) > 0;
                    end;
                    if Found then
                    begin
                      Fpos := FilePos(DBox) - Lpos;
                      if Fpos + maxL > FSize then
                      begin
                        Lpos := FilePos(DBox) + maxL - FSize;
                        Fpos := FSize - maxL;
                      end;
                      HoleLines(Kanal,Fpos);
                      if Lpos + Zmax - Y > maxL then Y := Lpos + Zmax - maxL;
                      DoPage(1,Zmax);
                    end else
                    begin
                      Seek(DBox,Fpos);
                      Alarm;
                    end;
                  end;
                  DoPage(Y,Y);
                end;

        _AltP : begin
                  if LPT_vorhanden and Lpt_All_Ok(PrtPort) then
                  begin
                    Seek(DBox,Fpos + Lpos - 1);
                    While not Eof(DBox) and not PrtFailure do
                    begin
                      BlockRead(DBox,HLstr,1,Result);
                      Hstr := MakeStr(HLstr,0,Attr);
                      KillEndBlanks(Hstr);
                      YScrolPos := Y + Yofs;
                      Write_Drucker(Kanal,Hstr + M1);
                    end;
                    Seek(DBox,Fpos);
                  end else
                  begin
                    WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,InfoZeile(290)));
                    Alarm;
                    Verzoegern(ZWEI);
                  end;
                  DoPage(Y,Y);
                end;

        _AltS : begin
                  WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,B1+InfoZeile(142)+B1));
                  Save_Name := G^.SavePfad + 'BOX'+ int_str(Kanal) + '.TXT';
                  GetString(Save_Name,Attrib[4],60,9,Y+Yofs,KC,1,Ins);
                  if KC <> _Esc then
                  begin
                    Assign(BoxSave,Save_Name);
                    Result := AppendTxt(BoxSave);
                    if Result <> 0 then Result := RewriteTxt(BoxSave);
                    if Result = 0 then
                    begin
                      Seek(DBox,Fpos + Lpos - 1);
                      While not Eof(DBox) do
                      begin
                        BlockRead(DBox,HLstr,1,Result);
                        Hstr := MakeStr(HLstr,0,Attr);
                        KillEndBlanks(Hstr);
                        Writeln(BoxSave,Hstr);
                      end;
                      FiResult := CloseTxt(BoxSave);
                      Seek(DBox,Fpos);
                    end else
                    begin
                      WriteRam(1,Y+Yofs,Attrib[4],1,EFillStr(80,B1,B1 +
                                        InfoZeile(75) + DP + B2 + Save_Name));
                      Alarm;
                      Verzoegern(ZWEI);
                    end;
                  end;
                  DoPage(Y,Y);
                end;

       _AltF1.._AltF10
              : SETNr := Ord(VC) - 103;

      _CtrlF1 : if G^.SETL[SETNr] > 0 then dec(G^.SETL[SETNr])
                                      else Alarm;

      _CtrlF2 : if G^.SETL[SETNr] < 365 then inc(G^.SETL[SETNr])
                                        else Alarm;

       _Right : if X < 80 then inc(X) else Alarm;

        _Left : if X > 1 then dec(X) else Alarm;

          _Up : CursorUp(Kanal);

          _Dn : CursorDown(Kanal);

        _PgUp : if (Y > 1) or (Fpos + Lpos > 1) then
                begin
                  Lpos := Lpos - Zmax + 1;

                  if Lpos - Y + 1 < 1 then
                  begin
                    Fpos := Fpos - maxL + Lpos + Zmax - Y;
                    Lpos := maxL - Zmax + Y;
                    if Fpos < 0 then
                    begin
                      Lpos := Lpos + Fpos;
                      Fpos := 0;
                    end;
                    HoleLines(Kanal,Fpos);
                  end;

                  if Lpos - Y + 1 < 1 then
                  begin
                    Lpos := 1;
                    Y := 1;
                  end;

                  DoPage(1,Zmax);
                end else Alarm;

        _PgDn : if (Y < Zmax) or (Fpos + Lpos < FSize) then
                begin
                  Lpos := Lpos + Zmax - 1;

                  if Lpos + Zmax - Y > maxL then
                  begin
                    Fpos := Fpos + Lpos - Y;
                    Lpos := Y;
                    if Fpos + maxL > FSize then
                    begin
                      Lpos := Fpos + maxL - FSize + Y;
                      Fpos := FSize - maxL;
                    end;
                    HoleLines(Kanal,Fpos);
                  end;

                  if Lpos + Zmax - Y > maxL then
                  begin
                    Lpos := maxL;
                    Y := Zmax;
                  end;
                  DoPage(1,Zmax);
                end else Alarm;

    _CtrlPgUp : if (Y > 1) or (Fpos + Lpos > 1) then
                begin
                  Fpos := 0;
                  Lpos := 1;
                  Y := 1;
                  HoleLines(Kanal,Fpos);
                  DoPage(1,Zmax);
                end else Alarm;

    _CtrlPgDn : if (Y < Zmax) or (Fpos + Lpos < FSize) or First then
                begin
                  First := false;
                  Fpos := FSize - maxL;
                  Lpos := maxL;
                  Y := Zmax;
                  HoleLines(Kanal,Fpos);
                  DoPage(1,Zmax);
                end else Alarm;

        _Home : begin
                  Fpos := BoxZlnMerk;
                  Lpos := 1;
                  Y := 1;
                  if Fpos + maxL > FSize then
                  begin
                    Lpos := Fpos + maxL - FSize + Y;
                    Fpos := FSize - maxL;
                  end;
                  if Lpos + Zmax - Y > maxL then Y := Lpos + Zmax - maxL;
                  HoleLines(Kanal,Fpos);
                  DoPage(1,Zmax);
                end;

        _End  : BoxZlnMerk := Fpos + Lpos - 1;

    _CtrlHome : begin
                  DoPage(Y,Y);
                  Lpos := Lpos - Y + 1;
                  Y := 1;
                end;

     _CtrlEnd : begin
                  DoPage(Y,Y);
                  Lpos := Lpos + Zmax - Y;
                  Y := Zmax;
                end;

       _ShTab : begin
                  CurObStat := not CurObStat;
                  if CurObStat then
                  begin
                    Xmerk := X;
                    X := ((NrStat[2]-1)*20)+1
                  end else X := XMerk;
                end;

       _ShDel : begin
                  Fpos := 0;
                  Lpos := 1;
                  Y := 1;
                  Seek(DBox,0);
                  Truncate(DBox);
                  FSize := 0;
                  BoxZlnMerk := 0;
                  FillChar(Lines^,SizeOf(Lines^),0);
                  Teil_Bild_Loesch(minY,maxY,Attrib[18]);
                end;

         _Nix : ;

           else Alarm;
      end;

      WriteAttr(1,Y+Yofs,80,Attrib[4],1);
      if HardCur and not VorEdit then
      begin
        if CurObStat then SetzeCursor(X,ObStat)
                     else SetzeCursor(X,Y+Yofs);
      end;
      Hstr := MakeStr(Lines^[Lpos],1,Attr);
      KillEndBlanks(Hstr);

      WriteRam(Nx+1,ObStat,Attrib[9],1,
       EFillStr(19,B1,EFillStr(9,B1,Hstr) +
                       SFillStr(5,B1,int_str(Fpos+Lpos)) +
                       SFillStr(4,B1,int_str(G^.SETL[SETNr])) ));
    Until Ende;

    if update then Updaten(Kanal);
    if not (SysArt in SysMenge) then CloseDBox(Kanal);
    FreeMem(Lines,SizeOf(Lines^));
    BoxScroll := false;
    Neu_Bild;
  end;
End;

Procedure CheckSort (* Kanal,Spalte,AnzSp : Byte; Dpos : LongInt; SC : Char *);
Const  maxSLines = 3000;

Type   LinePtr  = Array [1..maxSLines] of ^MbxZeile;

var    SFeld  : ^LinePtr;
       Mpos,
       Bpos,
       Epos   : LongInt;
       Hstr   : String[BoxRec];
       Hs     : MbxZeile;
       RFlag,
       bigger : Boolean;
       SC_Pos : Byte;
       maxS,
       i,Zx,
       Result : Word;
       Temp1,
       Temp2  : File;

  Procedure DBox_in_Buffer(Kanal : Byte);
  begin
    with K[Kanal]^ do
    begin
      Zx := 0;
      While (Zx < maxS) and (FilePos(DBox) <= Epos) do
      begin
        inc(Zx);
        BlockRead(DBox,SFeld^[Zx]^,1,Result);
      end;
      bigger := FilePos(DBox) <= Epos;
    end;
  end;

  Procedure SortBuffer(N : Word);
  Var  x,i,j  : Integer;
       Change : Boolean;
       CPtr   : Pointer;
  Begin
    if N > 1 then
    begin
      x := 1;
      While x <= N do x := x * 3 + 1;
      x := x div 3;
      While x > 0 do
      begin
        i := x;
        While i <= N do
        begin
          j := i - x;
          Change := true;
          While (j > 0) and Change do
          begin
            if copy(SFeld^[j]^,Spalte,AnzSp) >
               copy(SFeld^[j+x]^,Spalte,AnzSp) then
            begin
              CPtr := SFeld^[j+x];
              SFeld^[j+x] := SFeld^[j];
              SFeld^[j] := CPtr;
              j := j - x;
            end else Change := false;
          end;
          i := i + 1;
        end;
        x := x div 3;
      end;
    end;
  End;

Begin
  with K[Kanal]^ do
  begin
    SC_Pos := 82;
    Mpos := Dpos;
    Seek(DBox,Mpos);
    Repeat
      BlockRead(DBox,Hstr[1],1,Result);
      if Hstr[SC_Pos] = SC then inc(Mpos);
    Until Eof(DBox) or (Hstr[SC_Pos] <> SC);

    if Mpos > Dpos then
    begin
      dec(Mpos);
      Epos := Mpos;
      Repeat
        Seek(DBox,Mpos);
        BlockRead(DBox,Hstr[1],1,Result);
        if Hstr[SC_Pos] = SC then dec(Mpos);
      Until (Mpos < 0) or (Hstr[SC_Pos] <> SC);
      Bpos := Mpos + 1;

      maxS := 0;
      GetMem(SFeld,SizeOf(SFeld^));
      While (MaxAvail > 1000) and (maxS < maxSLines) do
      begin
        inc(maxS);
        GetMem(SFeld^[maxS],SizeOf(MbxZeile));
        FillChar(SFeld^[maxS]^,SizeOf(MbxZeile),0);
      end;

      Seek(DBox,Bpos);
      DBox_in_Buffer(Kanal);
      SortBuffer(Zx);

      if bigger then
      begin
        Assign(Temp1,G^.TempPfad + Tmp1Datei);
        FiResult := RewriteBin(Temp1,BoxRec);
        Assign(Temp2,G^.TempPfad + Tmp2Datei);
        FiResult := RewriteBin(Temp2,BoxRec);

        for i := 1 to Zx do BlockWrite(Temp1,SFeld^[i]^,1,Result);

        Repeat
          DBox_in_Buffer(Kanal);
          SortBuffer(Zx);
          i := 1;
          Seek(Temp1,0);
          if not Eof(Temp1) then
          begin
            BlockRead(Temp1,Hs,1,Result);
            RFlag := true;
          end else RFlag := false;

          Repeat
            if (not Eof(Temp1) or RFlag) and (i <= Zx) then
            begin
              if copy(SFeld^[i]^,Spalte,AnzSp) < copy(Hs,Spalte,AnzSp) then
              begin
                BlockWrite(Temp2,SFeld^[i]^,1,Result);
                inc(i);
              end else
              begin
                BlockWrite(Temp2,Hs,1,Result);
                if not Eof(Temp1) then
                begin
                  BlockRead(Temp1,Hs,1,Result);
                  RFlag := true;
                end else RFlag := false;
              end;
            end;

            if not RFlag and Eof(Temp1) then
            begin
              While i <= Zx do
              begin
                BlockWrite(Temp2,SFeld^[i]^,1,Result);
                inc(i);
              end;
            end;

            if i > Zx then
            begin
              if RFlag then BlockWrite(Temp2,Hs,1,Result);
              While not Eof(Temp1) do
              begin
                BlockRead(Temp1,Hs,1,Result);
                BlockWrite(Temp2,Hs,1,Result);
              end;
            end else
          Until Eof(Temp1) and (i > Zx);

          if bigger then
          begin
            FiResult := CloseBin(Temp1);
            FiResult := EraseBin(Temp1);

            FiResult := CloseBin(Temp2);
            Rename(Temp2,G^.TempPfad + Tmp1Datei);

            Assign(Temp1,G^.TempPfad + Tmp1Datei);
            FiResult := ResetBin(Temp1,BoxRec);

            Assign(Temp2,G^.TempPfad + Tmp2Datei);
            FiResult := RewriteBin(Temp2,BoxRec);
          end;
        Until not bigger;

        Seek(DBox,Bpos);
        Seek(Temp2,0);
        While not Eof(Temp2) do
        begin
          BlockRead(Temp2,Hs,1,Result);
          BlockWrite(DBox,Hs,1,Result);
        end;

        FiResult := CloseBin(Temp1);
        FiResult := CloseBin(Temp2);
        FiResult := EraseBin(Temp1);
        FiResult := EraseBin(Temp2);
      end else
      begin
        Seek(DBox,Bpos);
        for i := 1 to Zx do BlockWrite(DBox,SFeld^[i]^,1,Result);
      end;
      for i := 1 to maxS do FreeMem(SFeld^[i],SizeOf(MbxZeile));
      FreeMem(SFeld,SizeOf(SFeld^));
    end;
  end;
End;


Procedure OpenDBox (* Kanal : Byte *);
Begin
  with K[Kanal]^ do
  begin
    if not ChkLstOpen then
    begin
      if ResetBin(DBox,BoxRec) > 0 then FiResult := RewriteBin(DBox,BoxRec);
      FSize := FileSize(DBox);
      ChkLstOpen := true;
    end;
  end;
End;

Procedure CloseDBox(Kanal : Byte);
Var  Result : Word;
Begin
  with K[Kanal]^ do
  begin
    if ChkLstOpen then
    begin
      FiResult := CloseBin(DBox);
      ChkLstOpen := false;
    end;
  end;
End;